package 时间类

import (
	"time"
)

// HasError reports whether it has error.
// 是否有错误
func (c *Carbon) X是否有错误() bool {
	if c.X是否为空时间() {
		return false
	}
	return c.X错误 != nil
}

// IsNil reports whether is a nil time.
// 是否是空时间
func (c *Carbon) X是否为空时间() bool {
	if c == nil || &c.time == nil {
		return true
	}
	return false
}

// IsZero reports whether is a zero time(0001-01-01 00:00:00 +0000 UTC).
// 是否是零值时间(0001-01-01 00:00:00 +0000 UTC)
func (c *Carbon) X是否为零值时间() bool {
	if c.X是否为空时间() || c.X是否有错误() {
		return false
	}
	return c.time.IsZero()
}

// IsEpoch reports whether is a unix epoch time(1970-01-01 00:00:00 +0000 UTC).
// 是否是 UNIX 纪元时间(1970-01-01 00:00:00 +0000 UTC)
func (c *Carbon) X是否为UNIX时间() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Equal(time.Date(X常量_数字_UNIX纪元年, 1, 1, 0, 0, 0, 0, time.UTC))
}

// IsValid reports whether is a valid time.
// 是否是有效时间
func (c *Carbon) X是否为有效时间() bool {
	if !c.X是否为空时间() && !c.X是否有错误() {
		return true
	}
	return false
}

// IsInvalid reports whether is an invalid time.
// 是否是无效时间
func (c *Carbon) X是否为无效时间() bool {
	return !c.X是否为有效时间()
}

// IsDST reports whether is a daylight saving time.
// 是否是夏令时
func (c *Carbon) X是否为夏令时() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().IsDST()
}

// IsAM reports whether is before noon.
// 是否是上午
func (c *Carbon) X是否为上午() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("a") == "am"
}

// IsPM reports whether is after noon.
// 是否是下午
func (c *Carbon) X是否为下午() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("a") == "pm"
}

// IsLeapYear reports whether is a leap year.
// 是否是闰年
func (c *Carbon) X是否为闰年() bool {
	if c.X是否为无效时间() {
		return false
	}
	year := c.X取年()
	if year%400 == 0 || (year%4 == 0 && year%100 != 0) {
		return true
	}
	return false
}

// IsLongYear reports whether is a long year, see https://en.wikipedia.org/wiki/ISO_8601#Week_dates.
// 是否是长年
func (c *Carbon) X是否为长年() bool {
	if c.X是否为无效时间() {
		return false
	}
	_, w := time.Date(c.X取年(), 12, 31, 0, 0, 0, 0, c.loc).ISOWeek()
	return w == X常量_数字_每长年53周
}

// IsJanuary reports whether is January.
// 是否是一月
func (c *Carbon) X是否为一月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.January)
}

// IsFebruary reports whether is February.
// 是否是二月
func (c *Carbon) X是否为二月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.February)
}

// IsMarch reports whether is March.
// 是否是三月
func (c *Carbon) X是否为三月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.March)
}

// IsApril reports whether is April.
// 是否是四月
func (c *Carbon) X是否为四月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.April)
}

// IsMay reports whether is May.
// 是否是五月
func (c *Carbon) X是否为五月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.May)
}

// IsJune reports whether is June.
// 是否是六月
func (c *Carbon) X是否为六月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.June)
}

// IsJuly reports whether is July.
// 是否是七月
func (c *Carbon) X是否为七月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.July)
}

// IsAugust reports whether is August.
// 是否是八月
func (c *Carbon) X是否为八月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.August)
}

// IsSeptember reports whether is September.
// 是否是九月
func (c *Carbon) X是否为九月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.September)
}

// IsOctober reports whether is October.
// 是否是十月
func (c *Carbon) X是否为十月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.October)
}

// IsNovember reports whether is November.
// 是否是十一月
func (c *Carbon) X是否为十一月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.November)
}

// IsDecember reports whether is December.
// 是否是十二月
func (c *Carbon) X是否为十二月() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取月() == int(time.December)
}

// IsMonday reports whether is Monday.
// 是否是周一
func (c *Carbon) X是否为周一() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Monday
}

// IsTuesday reports whether is Tuesday.
// 是否是周二
func (c *Carbon) X是否为周二() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Tuesday
}

// IsWednesday reports whether is Wednesday.
// 是否是周三
func (c *Carbon) X是否为周三() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Wednesday
}

// IsThursday reports whether is Thursday.
// 是否是周四
func (c *Carbon) X是否为周四() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Thursday
}

// IsFriday reports whether is Friday.
// 是否是周五
func (c *Carbon) X是否为周五() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Friday
}

// IsSaturday reports whether is Saturday.
// 是否是周六
func (c *Carbon) X是否为周六() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Saturday
}

// IsSunday reports whether is Sunday.
// 是否是周日
func (c *Carbon) X是否为周日() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取Gosdk时间().Weekday() == time.Sunday
}

// IsWeekday reports whether is weekday.
// 是否是工作日
func (c *Carbon) X是否为工作日() bool {
	if c.X是否为无效时间() {
		return false
	}
	return !c.X是否为周末()
}

// IsWeekend reports whether is weekend.
// 是否是周末
func (c *Carbon) X是否为周末() bool {
	if c.X是否为无效时间() {
		return false
	}
	d := c.X取Gosdk时间().Weekday()
	for i := range c.weekendDays {
		if d == c.weekendDays[i] {
			return true
		}
	}
	return false
}

// IsNow reports whether is now time.
// 是否是当前时间
func (c *Carbon) X是否为当前时间() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取秒时间戳() == X创建并按当前时间(c.X取时区位置()).X取秒时间戳()
}

// IsFuture reports whether is future time.
// 是否是未来时间
func (c *Carbon) X是否为未来时间() bool {
	if c.X是否为无效时间() {
		return false
	}
	if c.X是否为零值时间() {
		return false
	}
	return c.X取秒时间戳() > X创建并按当前时间(c.X取时区位置()).X取秒时间戳()
}

// IsPast reports whether is past time.
// 是否是过去时间
func (c *Carbon) X是否为过去时间() bool {
	if c.X是否为无效时间() {
		return false
	}
	if c.X是否为零值时间() {
		return true
	}
	return c.X取秒时间戳() < X创建并按当前时间(c.X取时区位置()).X取秒时间戳()
}

// IsYesterday reports whether is yesterday.
// 是否是昨天
func (c *Carbon) X是否为昨天() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取文本日期() == X创建并按昨天时间().X取文本日期()
}

// IsToday reports whether is today.
// 是否是今天
func (c *Carbon) X是否为今天() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取文本日期() == X创建并按当前时间().X取文本日期()
}

// IsTomorrow reports whether is tomorrow.
// 是否是明天
func (c *Carbon) X是否为明天() bool {
	if c.X是否为无效时间() {
		return false
	}
	return c.X取文本日期() == X创建并按明天时间().X取文本日期()
}

// IsSameCentury reports whether is same century.
// 是否是同一世纪
func (c *Carbon) X是否为同一世纪(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取世纪() == t.X取世纪()
}

// IsSameDecade reports whether is same decade.
// 是否是同一年代
func (c *Carbon) X是否为同一年代(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取年代() == t.X取年代()
}

// IsSameYear reports whether is same year.
// 是否是同一年
func (c *Carbon) X是否为同一年(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取年() == t.X取年()
}

// IsSameQuarter reports whether is same quarter.
// 是否是同一季节
func (c *Carbon) X是否为同一季节(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取年() == t.X取年() && c.X取季度() == t.X取季度()
}

// IsSameMonth reports whether is same month.
// 是否是同一月
func (c *Carbon) X是否为同一月(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("Ym") == t.X取文本时间并按格式("Ym")
}

// IsSameDay reports whether is same day.
// 是否是同一天
func (c *Carbon) X是否为同一天(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("Ymd") == t.X取文本时间并按格式("Ymd")
}

// IsSameHour reports whether is same hour.
// 是否是同一小时
func (c *Carbon) X是否为同一小时(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("YmdH") == t.X取文本时间并按格式("YmdH")
}

// IsSameMinute reports whether is same minute.
// 是否是同一分钟
func (c *Carbon) X是否为同一分钟(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("YmdHi") == t.X取文本时间并按格式("YmdHi")
}

// IsSameSecond reports whether is same second.
// 是否是同一秒
func (c *Carbon) X是否为同一秒(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X取文本时间并按格式("YmdHis") == t.X取文本时间并按格式("YmdHis")

}

// Compare compares by an operator.
// 时间比较
func (c *Carbon) X时间比较(运算符 string, t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	switch 运算符 {
	case "=":
		return c.X是否等于(t)
	case "<>", "!=":
		return !c.X是否等于(t)
	case ">":
		return c.X是否大于(t)
	case ">=":
		return c.X是否大于等于(t)
	case "<":
		return c.X是否小于(t)
	case "<=":
		return c.X是否小于等于(t)
	}
	return false
}

// Gt reports whether greater than.
// 是否大于
func (c *Carbon) X是否大于(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.time.After(t.time)
}

// Lt reports whether less than.
// 是否小于
func (c *Carbon) X是否小于(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.time.Before(t.time)
}

// Eq reports whether equal.
// 是否等于
func (c *Carbon) X是否等于(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.time.Equal(t.time)
}

// Ne reports whether not equal.
// 是否不等于
func (c *Carbon) X是否不等于(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return !c.X是否等于(t)
}

// Gte reports whether greater than or equal.
// 是否大于等于
func (c *Carbon) X是否大于等于(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X是否大于(t) || c.X是否等于(t)
}

// Lte reports whether less than or equal.
// 是否小于等于
func (c *Carbon) X是否小于等于(t *Carbon) bool {
	if c.X是否为无效时间() || t.X是否为无效时间() {
		return false
	}
	return c.X是否小于(t) || c.X是否等于(t)
}

// Between reports whether between two times, excluded the start and end time.
// 是否在两个时间之间(不包括这两个时间)
func (c *Carbon) X是否在之间(开始 *Carbon, 结束 *Carbon) bool {
	if c.X是否为无效时间() || 开始.X是否为无效时间() || 结束.X是否为无效时间() {
		return false
	}
	if 开始.X是否大于(结束) {
		return false
	}
	if c.X是否大于(开始) && c.X是否小于(结束) {
		return true
	}
	return false
}

// BetweenIncludedStart reports whether between two times, included the start time.
// 是否在两个时间之间(包括开始时间)
func (c *Carbon) X是否在之间并含开始时间(开始 *Carbon, 结束 *Carbon) bool {
	if c.X是否为无效时间() || 开始.X是否为无效时间() || 结束.X是否为无效时间() {
		return false
	}
	if 开始.X是否大于(结束) {
		return false
	}
	if c.X是否大于等于(开始) && c.X是否小于(结束) {
		return true
	}
	return false
}

// BetweenIncludedEnd reports whether between two times, included the end time.
// 是否在两个时间之间(包括结束时间)
func (c *Carbon) X是否在之间并含结束时间(开始 *Carbon, 结束 *Carbon) bool {
	if c.X是否为无效时间() || 开始.X是否为无效时间() || 结束.X是否为无效时间() {
		return false
	}
	if 开始.X是否大于(结束) {
		return false
	}
	if c.X是否大于(开始) && c.X是否小于等于(结束) {
		return true
	}
	return false
}

// BetweenIncludedBoth reports whether between two times, included the start and end time.
// 是否在两个时间之间(包括这两个时间)
func (c *Carbon) X是否在之间并含开始结束时间(开始 *Carbon, 结束 *Carbon) bool {
	if c.X是否为无效时间() || 开始.X是否为无效时间() || 结束.X是否为无效时间() {
		return false
	}
	if 开始.X是否大于(结束) {
		return false
	}
	if c.X是否大于等于(开始) && c.X是否小于等于(结束) {
		return true
	}
	return false
}
